@likec4/language-server 1.17.0 → 1.18.0

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

@@ -1,1967 +0,0 @@
-'use strict';
-
-const core = require('@likec4/core');
-const remeda = require('remeda');
-const dagre = require('@dagrejs/dagre');
-const log = require('@likec4/log');
-const objectHash = require('object-hash');
-
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
-
-const dagre__default = /*#__PURE__*/_interopDefaultCompat(dagre);
-const objectHash__default = /*#__PURE__*/_interopDefaultCompat(objectHash);
-
-function resolveGlobalRulesInElementView(view, globals) {
-  return view.rules.reduce((acc, rule) => {
-    if (core.isViewRuleGlobalPredicateRef(rule)) {
-      const globalPredicates = globals.predicates[rule.predicateId];
-      if (remeda.isNullish(globalPredicates)) {
-        log.logger.warn(`Global predicate not found: ${rule.predicateId}`);
-        return acc;
-      }
-      return acc.concat(globalPredicates);
-    }
-    if (core.isViewRuleGlobalStyle(rule)) {
-      const globalStyles = globals.styles[rule.styleId];
-      if (remeda.isNullish(globalStyles)) {
-        log.logger.warn(`Global style not found: ${rule.styleId}`);
-        return acc;
-      }
-      return acc.concat(globalStyles);
-    }
-    acc.push(rule);
-    return acc;
-  }, []);
-}
-function resolveGlobalRulesInDynamicView(view, globals) {
-  return view.rules.reduce((acc, rule) => {
-    if (core.isViewRuleGlobalPredicateRef(rule)) {
-      const globalPredicates = globals.dynamicPredicates[rule.predicateId];
-      if (remeda.isNullish(globalPredicates)) {
-        log.logger.warn(`Global predicate not found: ${rule.predicateId}`);
-        return acc;
-      }
-      return acc.concat(globalPredicates);
-    }
-    if (core.isViewRuleGlobalStyle(rule)) {
-      const globalStyles = globals.styles[rule.styleId];
-      if (remeda.isNullish(globalStyles)) {
-        log.logger.warn(`Global style not found: ${rule.styleId}`);
-        return acc;
-      }
-      return acc.concat(globalStyles);
-    }
-    acc.push(rule);
-    return acc;
-  }, []);
-}
-
-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 flattenGroupRules(guard) {
-  return (rule) => {
-    if (core.isViewRuleGroup(rule)) {
-      return rule.groupRules.flatMap(flattenGroupRules(guard));
-    }
-    if (core.isViewRulePredicate(rule)) {
-      return "include" in rule ? rule.include.filter(guard) : [];
-    }
-    return [];
-  };
-}
-function applyCustomElementProperties(_rules, _nodes) {
-  const rules = _rules.flatMap(flattenGroupRules(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 (core.ComputedNode.isNodesGroup(node) || !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):
-      const predicate = relationExpressionToPredicates(expr.where.expr);
-      const where = core.whereOperatorAsPredicate(expr.where.condition);
-      return (e) => predicate(e) && where(e);
-    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(flattenGroupRules(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, ...remeda.pick(edge, ["kind", "tags"]) })) {
-        edges[i] = {
-          ...edge,
-          ...props,
-          label: title ?? edge.label,
-          isCustomized: true
-        };
-      }
-    });
-  }
-  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) {
-      predicates.push(elementExprToPredicate(target));
-    }
-    remeda.pipe(
-      nodes,
-      remeda.filter(remeda.isNot(core.ComputedNode.isNodesGroup)),
-      remeda.filter(remeda.anyPass(predicates)),
-      remeda.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, groups) {
-  const nodesMap = /* @__PURE__ */ new Map();
-  const elementToGroup = /* @__PURE__ */ new Map();
-  groups?.forEach(({ id, parent, viewRule, explicits }) => {
-    if (parent) {
-      core.nonNullable(nodesMap.get(parent), `Parent group node ${parent} not found`).children.push(id);
-    }
-    nodesMap.set(id, {
-      id,
-      parent,
-      kind: core.ElementKind.Group,
-      title: viewRule.title ?? "",
-      color: viewRule.color ?? "muted",
-      shape: "rectangle",
-      children: [],
-      inEdges: [],
-      outEdges: [],
-      level: 0,
-      depth: 0,
-      description: null,
-      technology: null,
-      tags: null,
-      links: null,
-      style: {
-        border: viewRule.border ?? "dashed",
-        opacity: viewRule.opacity ?? 0
-      }
-    });
-    for (const e of explicits) {
-      elementToGroup.set(e.id, id);
-    }
-  });
-  return Array.from(elements).sort(core.compareByFqnHierarchically).reduce((map, { id, color, shape, style, kind, title, ...el }) => {
-    let parent = core.parentFqn(id);
-    let level = 0;
-    let parentNd;
-    while (parent) {
-      parentNd = map.get(parent);
-      if (parentNd) {
-        break;
-      }
-      parent = core.parentFqn(parent);
-    }
-    if (!parentNd && elementToGroup.has(id)) {
-      parent = elementToGroup.get(id);
-      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;
-    }
-    const node = {
-      id,
-      parent,
-      kind,
-      title,
-      color: color ?? core.DefaultThemeColor,
-      shape: shape ?? core.DefaultElementShape,
-      children: [],
-      inEdges: [],
-      outEdges: [],
-      level,
-      ...el,
-      style: {
-        ...style
-      }
-    };
-    map.set(id, node);
-    return map;
-  }, nodesMap);
-}
-
-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("shape"),
-      remeda.prop("title"),
-      [
-        (n) => n.kinds.length,
-        "desc"
-      ]
-    )
-  );
-}
-
-const Graph = dagre__default.graphlib.Graph;
-const postorder = dagre__default.graphlib.alg.postorder;
-const findCycles = dagre__default.graphlib.alg.findCycles;
-const isAcyclic = dagre__default.graphlib.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 (nodes.length < 2) {
-    return nodes;
-  }
-  if (edges.length === 0) {
-    return remeda.pipe(
-      nodes,
-      remeda.sort(core.compareByFqnHierarchically),
-      remeda.tap(sortChildren)
-    );
-  }
-  const g = new 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, 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.filter((n) => n.inEdges.length === 0 || n.parent === null),
-      remeda.sort(core.compareByFqnHierarchically),
-      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).sort(core.compareByFqnHierarchically);
-    sorted.push(...unsorted);
-  }
-  core.invariant(sorted.length === nodes.length, "Not all nodes were processed by graphlib");
-  sortChildren(sorted);
-  return sorted;
-}
-
-function uniqueTags(elements) {
-  const tags = remeda.pipe(
-    elements,
-    remeda.flatMap((e) => e.tags ?? []),
-    remeda.unique(),
-    remeda.sort(core.compareNatural)
-  );
-  return core.hasAtLeast(tags, 1) ? tags : null;
-}
-
-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)).forEach((edge) => {
-      this.addImplicit(edge.source, edge.target);
-    });
-  }
-  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) => {
-  return remeda.pipe(
-    edges,
-    remeda.flatMap((e) => e.relations),
-    where ? remeda.filter(where) : Identity,
-    remeda.unique()
-  );
-};
-function includeIncomingExpr(expr, where) {
-  const edges = filterEdges(edgesIncomingExpr.call(this, expr.incoming), where);
-  if (edges.length === 0) {
-    return;
-  }
-  this.addEdges(edges).forEach((edge) => {
-    this.addImplicit(edge.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).forEach((edge) => {
-    this.addImplicit(edge.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)).forEach((edge) => {
-    this.activeGroup.addImplicit(edge.source, edge.target);
-  });
-}
-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 NodesGroup {
-  constructor(id, viewRule, parent = null) {
-    this.id = id;
-    this.viewRule = viewRule;
-    this.parent = parent;
-  }
-  static kind = core.ElementKind.Group;
-  static root() {
-    return new NodesGroup("@root", { title: null, groupRules: [] });
-  }
-  static is(node) {
-    return node.kind === NodesGroup.kind;
-  }
-  explicits = /* @__PURE__ */ new Set();
-  implicits = /* @__PURE__ */ new Set();
-  /**
-   * 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.explicits.delete(el);
-      this.implicits.delete(el);
-    }
-  }
-  isEmpty() {
-    return this.explicits.size === 0 && this.implicits.size === 0;
-  }
-}
-class ComputeCtx {
-  constructor(view, graph) {
-    this.view = view;
-    this.graph = graph;
-  }
-  // Intermediate state
-  explicits = /* @__PURE__ */ new Set();
-  implicits = /* @__PURE__ */ new Set();
-  ctxEdges = [];
-  /**
-   * Root group - not included in the groups
-   * But used to accumulate elements that are not in any group
-   */
-  __rootGroup = NodesGroup.root();
-  groups = [];
-  activeGroupStack = [];
-  get activeGroup() {
-    return this.activeGroupStack[0] ?? this.__rootGroup;
-  }
-  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;
-  }
-  get root() {
-    return core.isScopedElementView(this.view) ? this.view.viewOf : null;
-  }
-  static elementView(view, graph) {
-    return new ComputeCtx(view, graph).compute();
-  }
-  compute() {
-    this.reset();
-    const {
-      docUri: _docUri,
-      // exclude docUri
-      rules: _rules,
-      // exclude rules
-      ...view
-    } = this.view;
-    const rules = resolveGlobalRulesInElementView(this.view, this.graph.globals);
-    const viewPredicates = rules.filter(remeda.anyPass([core.isViewRulePredicate, core.isViewRuleGroup]));
-    if (this.root && viewPredicates.length == 0) {
-      this.addElement(this.graph.element(this.root));
-    }
-    this.processPredicates(viewPredicates);
-    this.removeRedundantImplicitEdges();
-    if (this.groups.length > 0) {
-      this.cleanGroupElements();
-    }
-    const elements = [...this.includedElements];
-    const nodesMap = buildComputeNodes(elements, this.groups);
-    const edges = this.computeEdges();
-    const edgesMap = new Map(edges.map((edge) => [edge.id, edge]));
-    this.linkNodesAndEdges(nodesMap, edges);
-    let initialSort = elements.map((e) => core.nonNullable(nodesMap.get(e.id), `Node ${e.id} not found in nodesMap`));
-    if (this.groups.length > 0) {
-      initialSort = remeda.concat(
-        this.groups.map((g) => core.nonNullable(nodesMap.get(g.id), `Node ${g.id} not found in nodesMap`)),
-        initialSort
-      );
-    }
-    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: {
-        direction: autoLayoutRule?.direction ?? "TB",
-        ...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
-        ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
-      },
-      nodes: remeda.map(nodes, (n) => {
-        delete n.notation;
-        if (n.icon === "none") {
-          delete n.icon;
-        }
-        return n;
-      }),
-      edges: applyCustomRelationProperties(rules, nodes, sortedEdges),
-      ...elementNotations.length > 0 && {
-        notation: {
-          elements: elementNotations
-        }
-      }
-    });
-  }
-  computeEdges() {
-    return this.ctxEdges.map((e) => {
-      core.invariant(remeda.hasAtLeast(e.relations, 1), "Edge must have at least one relation");
-      const relations = remeda.sort(e.relations, 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;
-      relation = remeda.only(relations) ?? remeda.pipe(
-        relations,
-        remeda.filter((r) => r.source === source && r.target === target),
-        remeda.only()
-      );
-      if (!relation) {
-        const allprops = remeda.pipe(
-          relations,
-          remeda.reduce((acc, r) => {
-            if (remeda.isTruthy(r.title) && !acc.title.includes(r.title)) {
-              acc.title.push(r.title);
-            }
-            if (remeda.isTruthy(r.description) && !acc.description.includes(r.description)) {
-              acc.description.push(r.description);
-            }
-            if (remeda.isTruthy(r.technology) && !acc.technology.includes(r.technology)) {
-              acc.technology.push(r.technology);
-            }
-            if (remeda.isTruthy(r.kind) && !acc.kind.includes(r.kind)) {
-              acc.kind.push(r.kind);
-            }
-            if (remeda.isTruthy(r.color) && !acc.color.includes(r.color)) {
-              acc.color.push(r.color);
-            }
-            if (remeda.isTruthy(r.line) && !acc.line.includes(r.line)) {
-              acc.line.push(r.line);
-            }
-            if (remeda.isTruthy(r.head) && !acc.head.includes(r.head)) {
-              acc.head.push(r.head);
-            }
-            if (remeda.isTruthy(r.tail) && !acc.tail.includes(r.tail)) {
-              acc.tail.push(r.tail);
-            }
-            if (remeda.isTruthy(r.navigateTo) && !acc.navigateTo.includes(r.navigateTo)) {
-              acc.navigateTo.push(r.navigateTo);
-            }
-            return acc;
-          }, {
-            title: [],
-            description: [],
-            technology: [],
-            kind: [],
-            head: [],
-            tail: [],
-            color: [],
-            line: [],
-            navigateTo: []
-          })
-        );
-        relation = {
-          title: remeda.only(allprops.title) ?? "[...]",
-          description: remeda.only(allprops.description),
-          technology: remeda.only(allprops.technology),
-          kind: remeda.only(allprops.kind),
-          head: remeda.only(allprops.head),
-          tail: remeda.only(allprops.tail),
-          color: remeda.only(allprops.color),
-          line: remeda.only(allprops.line),
-          navigateTo: remeda.only(allprops.navigateTo)
-        };
-      }
-      const tags = uniqueTags(relations);
-      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 },
-        relation.navigateTo && { navigateTo: relation.navigateTo },
-        tags && { tags }
-      );
-    });
-  }
-  linkNodesAndEdges(nodesMap, edges) {
-    for (const edge of edges) {
-      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`);
-      const sourceAncestors = this.ancestorsOf(source, nodesMap);
-      const targetAncestors = this.ancestorsOf(target, nodesMap);
-      const edgeParent = remeda.last(
-        core.commonHead(
-          remeda.reverse(sourceAncestors),
-          remeda.reverse(targetAncestors)
-        )
-      );
-      edge.parent = edgeParent?.id ?? null;
-      source.outEdges.push(edge.id);
-      target.inEdges.push(edge.id);
-      for (const sourceAncestor of sourceAncestors) {
-        if (sourceAncestor === edgeParent) {
-          break;
-        }
-        sourceAncestor.outEdges.push(edge.id);
-      }
-      for (const targetAncestor of targetAncestors) {
-        if (targetAncestor === edgeParent) {
-          break;
-        }
-        targetAncestor.inEdges.push(edge.id);
-      }
-    }
-  }
-  addEdges(edges) {
-    const added = [];
-    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]);
-        added.push(existing);
-        continue;
-      }
-      added.push(e);
-      this.ctxEdges.push(e);
-    }
-    return added;
-  }
-  /**
-   * Add element explicitly
-   * Included even without relationships
-   */
-  addElement(...el) {
-    for (const r of el) {
-      if (!this.explicits.has(r)) {
-        this.activeGroup.addElement(r);
-      } else if (this.activeGroup !== this.__rootGroup) {
-        this.groups.forEach((g) => {
-          g.implicits.delete(r);
-        });
-        this.activeGroup.addImplicit(r);
-      }
-      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);
-      if (this.activeGroup !== this.__rootGroup) {
-        this.groups.forEach((g) => {
-          g.implicits.delete(r);
-        });
-      }
-    }
-    this.activeGroup.addImplicit(...el);
-  }
-  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);
-    }
-    this.__rootGroup.excludeElement(...excludes);
-    this.groups.forEach((g) => {
-      g.excludeElement(...excludes);
-    });
-  }
-  excludeRelation(...relations) {
-    if (relations.length === 0) {
-      return;
-    }
-    const excludedImplicits = /* @__PURE__ */ new Set();
-    const ctxEdges = remeda.pipe(
-      this.ctxEdges,
-      remeda.map((edge) => {
-        const edgerelations = edge.relations.filter((r) => !relations.includes(r));
-        if (edgerelations.length === 0) {
-          excludedImplicits.add(edge.source);
-          excludedImplicits.add(edge.target);
-          return null;
-        }
-        if (edgerelations.length !== edge.relations.length) {
-          return {
-            ...edge,
-            relations: edgerelations
-          };
-        }
-        return edge;
-      }),
-      remeda.filter(remeda.isNonNull)
-    );
-    this.ctxEdges = ctxEdges;
-    const remaining = this.includedElements;
-    if (remaining.size === 0) {
-      this.implicits.clear();
-      this.__rootGroup.implicits.clear();
-      this.groups.forEach((g) => g.implicits.clear());
-      return;
-    }
-    for (const el of excludedImplicits) {
-      if (!remaining.has(el)) {
-        this.implicits.delete(el);
-        this.__rootGroup.implicits.delete(el);
-        this.groups.forEach((g) => g.implicits.delete(el));
-      }
-    }
-  }
-  reset() {
-    this.explicits.clear();
-    this.implicits.clear();
-    this.ctxEdges = [];
-    this.__rootGroup = NodesGroup.root();
-    this.groups = [];
-    this.activeGroupStack = [];
-  }
-  // 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;
-    }, []);
-  }
-  cleanGroupElements() {
-    const unprocessed = new Set(remeda.difference(
-      [...this.includedElements],
-      [...this.__rootGroup.explicits]
-    ));
-    for (const group of this.groups) {
-      const explicits = [...group.explicits];
-      group.explicits.clear();
-      for (const el of explicits) {
-        if (unprocessed.delete(el)) {
-          group.explicits.add(el);
-        }
-      }
-    }
-    for (const group of this.groups) {
-      for (const el of group.implicits) {
-        if (unprocessed.delete(el)) {
-          group.explicits.add(el);
-        }
-      }
-      group.implicits.clear();
-    }
-  }
-  processPredicates(viewRules) {
-    for (const rule of viewRules) {
-      if (core.isViewRuleGroup(rule)) {
-        const parent = remeda.first(this.activeGroupStack);
-        const groupId = `@gr${this.groups.length + 1}`;
-        const group = new NodesGroup(groupId, rule, parent?.id ?? null);
-        this.groups.push(group);
-        this.activeGroupStack.unshift(group);
-        this.processPredicates(rule.groupRules);
-        this.activeGroupStack.shift();
-        continue;
-      }
-      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);
-  }
-  ancestorsOf(node, nodesMap) {
-    const ancestors = [];
-    let parent = node.parent;
-    while (parent) {
-      const parentNode = nodesMap.get(parent);
-      if (!parentNode) {
-        break;
-      }
-      ancestors.push(parentNode);
-      parent = parentNode.parent;
-    }
-    return ancestors;
-  }
-  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();
-  }
-  addStep({
-    source: stepSource,
-    target: stepTarget,
-    title: stepTitle,
-    isBackward,
-    navigateTo: stepNavigateTo,
-    ...step
-  }, index, parent) {
-    const id = parent ? core.StepEdgeId(parent, index) : core.StepEdgeId(index);
-    const source = this.graph.element(stepSource);
-    const target = this.graph.element(stepTarget);
-    this.explicits.add(source);
-    this.explicits.add(target);
-    const {
-      title,
-      relations,
-      tags,
-      navigateTo: derivedNavigateTo
-    } = this.findRelations(source, target);
-    const navigateTo = remeda.isTruthy(stepNavigateTo) && stepNavigateTo !== this.view.id ? stepNavigateTo : derivedNavigateTo;
-    this.steps.push({
-      id,
-      ...step,
-      source,
-      target,
-      title: stepTitle ?? title,
-      relations: relations ?? [],
-      isBackward: isBackward ?? false,
-      ...navigateTo ? { navigateTo } : {},
-      ...tags ? { tags } : {}
-    });
-  }
-  compute() {
-    const {
-      docUri: _docUri,
-      // exclude docUri
-      rules: _rules,
-      // exclude rules
-      steps: viewSteps,
-      ...view
-    } = this.view;
-    let stepNum = 1;
-    for (const step of viewSteps) {
-      if (core.isDynamicViewParallelSteps(step)) {
-        if (step.__parallel.length === 0) {
-          continue;
-        }
-        if (step.__parallel.length === 1) {
-          this.addStep(step.__parallel[0], stepNum);
-        } else {
-          step.__parallel.forEach((s, i) => this.addStep(s, i + 1, stepNum));
-        }
-      } else {
-        this.addStep(step, stepNum);
-      }
-      stepNum++;
-    }
-    const rules = resolveGlobalRulesInDynamicView(this.view, this.graph.globals);
-    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 }) => {
-      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 edge = {
-        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: {
-        direction: autoLayoutRule?.direction ?? "LR",
-        ...autoLayoutRule?.nodeSep && { nodeSep: autoLayoutRule.nodeSep },
-        ...autoLayoutRule?.rankSep && { rankSep: autoLayoutRule.rankSep }
-      },
-      nodes: remeda.map(nodes, (n) => {
-        delete n.notation;
-        if (n.icon === "none") {
-          delete n.icon;
-        }
-        return n;
-      }),
-      edges,
-      ...elementNotations.length > 0 && {
-        notation: {
-          elements: elementNotations
-        }
-      }
-    });
-  }
-  findRelations(source, target) {
-    const relationships = remeda.unique(this.graph.edgesBetween(source, target).flatMap((e) => e.relations));
-    if (relationships.length === 0) {
-      return {
-        title: null,
-        tags: null,
-        relations: null,
-        navigateTo: null
-      };
-    }
-    const alltags = remeda.pipe(
-      relationships,
-      remeda.flatMap((r) => r.tags),
-      remeda.filter(remeda.isTruthy),
-      remeda.unique()
-    );
-    const tags = remeda.hasAtLeast(alltags, 1) ? alltags : null;
-    const relations = remeda.hasAtLeast(relationships, 1) ? remeda.map(relationships, (r) => r.id) : null;
-    const relation = remeda.only(relationships) || relationships.find((r) => r.source === source.id && r.target === target.id);
-    const title = remeda.isTruthy(relation?.title) ? relation.title : remeda.pipe(
-      relationships,
-      remeda.map((r) => r.title),
-      remeda.filter(remeda.isTruthy),
-      remeda.unique(),
-      remeda.only()
-    );
-    const navigateTo = !!relation?.navigateTo && relation.navigateTo !== this.view.id ? relation.navigateTo : remeda.pipe(
-      relationships,
-      remeda.map((r) => r.navigateTo),
-      remeda.filter(remeda.isTruthy),
-      remeda.filter((v) => v !== this.view.id),
-      remeda.unique(),
-      remeda.only()
-    );
-    return {
-      title: title ?? null,
-      tags,
-      relations,
-      navigateTo: navigateTo ?? null
-    };
-  }
-}
-
-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();
-  globals;
-  constructor({ elements, relations, globals }) {
-    this.globals = globals ?? {
-      predicates: {},
-      dynamicPredicates: {},
-      styles: {}
-    };
-    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.Graph = Graph;
-exports.LikeC4ModelGraph = LikeC4ModelGraph;
-exports.computeDynamicView = computeDynamicView;
-exports.computeElementView = computeElementView;
-exports.computeView = computeView;
-exports.findCycles = findCycles;
-exports.isAcyclic = isAcyclic;
-exports.postorder = postorder;