@likec4/core 0.37.1 → 0.41.0

package/dist/compute-view/compute-predicates.cjs

@@ -1,363 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.includeWildcardRef = exports.includeRelationExpr = exports.includeOutgoingExpr = exports.includeIncomingExpr = exports.includeInOutExpr = exports.includeElementRef = exports.includeElementKindOrTag = exports.excludeWildcardRef = exports.excludeRelationExpr = exports.excludeOutgoingExpr = exports.excludeIncomingExpr = exports.excludeInOutExpr = exports.excludeElementRef = exports.excludeElementKindOrTag = void 0;
-var _rambdax = require("rambdax");
-var _types = require("../types/index.cjs");
-var _utils = require("../utils/index.cjs");
-var _computeCtx = require("./compute-ctx.cjs");
-const {
-  isAnyInOut,
-  isBetween,
-  isIncoming,
-  isInside,
-  isOutgoing,
-  isAnyBetween
-} = _utils.Relations;
-const includeElementRef = (ctx, expr) => {
-  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const filters = [];
-  if (expr.isDescedants) {
-    elements.forEach(child => {
-      filters.push((0, _rambdax.both)(isInside(expr.element), isAnyInOut(child.id)));
-    });
-  }
-  const ctxElements = (0, _rambdax.uniq)([...ctx.elements, ...ctx.implicits]);
-  const excludeImplicits = [];
-  for (const el of elements) {
-    if (ctx.root && ctx.root !== el.id && !(0, _utils.isAncestor)(el.id, ctx.root)) {
-      excludeImplicits.push(...[...ctx.implicits].filter(impl => (0, _utils.isAncestor)(el.id, impl.id)));
-    }
-    for (const ctxEl of ctxElements) {
-      if (!(0, _utils.isSameHierarchy)(el, ctxEl)) {
-        filters.push(isAnyBetween(el.id, ctxEl.id));
-      }
-    }
-  }
-  const relations = filters.length ? ctx.index.filterRelations((0, _rambdax.anyPass)(filters)) : [];
-  if (excludeImplicits.length == 0) {
-    return ctx.include({
-      elements,
-      relations
-    });
-  }
-  return ctx.include({
-    elements,
-    relations
-  }).exclude({
-    implicits: excludeImplicits
-  });
-};
-exports.includeElementRef = includeElementRef;
-const excludeElementRef = (ctx, expr) => {
-  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const elementsIds = elements.map(e => e.id);
-  const relations = [...ctx.relations].filter(r => elementsIds.includes(r.source) || elementsIds.includes(r.target));
-  return ctx.exclude({
-    elements,
-    relations
-  });
-};
-exports.excludeElementRef = excludeElementRef;
-const asElementPredicate = expr => {
-  if (expr.isEqual) {
-    if (_types.Expr.isElementKindExpr(expr)) {
-      return e => e.kind === expr.elementKind;
-    } else {
-      return ({
-        tags
-      }) => !!tags && tags.includes(expr.elementTag);
-    }
-  } else {
-    if (_types.Expr.isElementKindExpr(expr)) {
-      return e => e.kind !== expr.elementKind;
-    } else {
-      return ({
-        tags
-      }) => (0, _rambdax.isNil)(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    }
-  }
-};
-const includeElementKindOrTag = (ctx, expr) => {
-  const elements = ctx.index.elements.filter(asElementPredicate(expr));
-  return elements.reduce((accCtx, el) => includeElementRef(accCtx, {
-    element: el.id,
-    isDescedants: false
-  }), ctx);
-};
-exports.includeElementKindOrTag = includeElementKindOrTag;
-const excludeElementKindOrTag = (ctx, expr) => {
-  const predicate = asElementPredicate(expr);
-  const elements = [...ctx.elements].filter(predicate);
-  const implicits = [...ctx.implicits].filter(predicate);
-  return ctx.exclude({
-    elements,
-    implicits
-  });
-};
-exports.excludeElementKindOrTag = excludeElementKindOrTag;
-const includeWildcardRef = (ctx, _expr) => {
-  const {
-    root
-  } = ctx;
-  if (root) {
-    const elements = [ctx.index.find(root), ...ctx.index.children(root)];
-    const allImplicits = [...ctx.index.siblings(root), ...ctx.index.ancestors(root).flatMap(a => [...ctx.index.siblings(a.id)])];
-    const inOut = ctx.index.filterRelations(isAnyInOut(root));
-    const implicits = [];
-    for (const implicit of allImplicits) {
-      if (inOut.some(isAnyInOut(implicit.id))) {
-        implicits.push(implicit);
-      }
-    }
-    return ctx.include({
-      elements,
-      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
-      implicits
-    });
-  } else {
-    const elements = ctx.index.rootElements();
-    if (elements.length <= 1) {
-      return new _computeCtx.ComputeCtx(ctx.index, ctx.root, new Set(elements));
-    }
-    const relations = ctx.index.filterRelations(rel => (0, _rambdax.isNil)((0, _utils.commonAncestor)(rel.source, rel.target)));
-    return ctx.include({
-      elements,
-      relations
-    });
-  }
-};
-exports.includeWildcardRef = includeWildcardRef;
-const excludeWildcardRef = (ctx, _expr) => {
-  const {
-    root
-  } = ctx;
-  if (root) {
-    const relations = [...ctx.relations].filter((0, _rambdax.either)(isInside(root), isAnyInOut(root)));
-    return ctx.exclude({
-      elements: [...ctx.elements].filter(e => e.id === root || (0, _utils.isAncestor)(root, e.id)),
-      relations,
-      implicits: [...ctx.implicits].filter(e => relations.some(isAnyInOut(e.id)))
-    });
-  } else {
-    return new _computeCtx.ComputeCtx(ctx.index, ctx.root);
-  }
-};
-exports.excludeWildcardRef = excludeWildcardRef;
-const resolveElements = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr)) {
-    if (ctx.root) {
-      return [ctx.index.find(ctx.root)];
-    } else {
-      return ctx.index.rootElements();
-    }
-  }
-  if (_types.Expr.isElementKindExpr(expr)) {
-    return ctx.index.elements.filter(el => {
-      if (expr.isEqual) {
-        return el.kind === expr.elementKind;
-      }
-      return el.kind !== expr.elementKind;
-    });
-  }
-  if (_types.Expr.isElementTagExpr(expr)) {
-    return ctx.index.elements.filter(el => {
-      const tags = el.tags;
-      if (expr.isEqual) {
-        return !!tags && tags.includes(expr.elementTag);
-      }
-      return (0, _rambdax.isNil)(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    });
-  }
-  if (expr.isDescedants) {
-    return ctx.index.children(expr.element);
-  } else {
-    return [ctx.index.find(expr.element)];
-  }
-};
-const includeIncomingExpr = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (_types.Expr.isElementRef(expr.incoming)) {
-    allrelations = allrelations.filter(isIncoming(expr.incoming.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isIncoming(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-exports.includeIncomingExpr = includeIncomingExpr;
-const excludeIncomingExpr = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isIncomings = (0, _rambdax.anyPass)(elements.map(el => isIncoming(el.id)));
-  const excluded = [...ctx.relations].filter(isIncomings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-exports.excludeIncomingExpr = excludeIncomingExpr;
-const includeOutgoingExpr = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (_types.Expr.isElementRef(expr.outgoing)) {
-    allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isOutgoing(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-exports.includeOutgoingExpr = includeOutgoingExpr;
-const excludeOutgoingExpr = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isOutgoings = (0, _rambdax.anyPass)(elements.map(el => isOutgoing(el.id)));
-  const excluded = [...ctx.relations].filter(isOutgoings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-exports.excludeOutgoingExpr = excludeOutgoingExpr;
-const includeInOutExpr = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (_types.Expr.isElementRef(expr.inout)) {
-    allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const target of targets) {
-    const foundRelations = allrelations.filter(isAnyInOut(target.id));
-    if (foundRelations.length > 0) {
-      relations.push(...foundRelations);
-      implicits.push(target);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-exports.includeInOutExpr = includeInOutExpr;
-const excludeInOutExpr = (ctx, expr) => {
-  if (_types.Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter((0, _rambdax.anyPass)(targets.map(t => isAnyInOut(t.id))));
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-exports.excludeInOutExpr = excludeInOutExpr;
-const includeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  if (sources.length === 0 || targets.length === 0) {
-    return ctx;
-  }
-  const implicits = [];
-  const relations = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if ((0, _utils.isSameHierarchy)(source, target)) {
-        continue;
-      }
-      const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
-      if (foundRelations.length > 0) {
-        relations.push(...foundRelations);
-        implicits.push(source, target);
-      }
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-exports.includeRelationExpr = includeRelationExpr;
-const excludeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  const filters = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if ((0, _utils.isSameHierarchy)(source, target)) {
-        continue;
-      }
-      filters.push(isBetween(source.id, target.id));
-    }
-  }
-  if (filters.length == 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter((0, _rambdax.anyPass)(filters));
-  if (excluded.length == 0) {
-    return ctx;
-  }
-  return ctx.exclude({
-    relations: excluded
-  });
-};
-exports.excludeRelationExpr = excludeRelationExpr;

package/dist/compute-view/compute-predicates.d.ts

@@ -1,16 +0,0 @@
-import { Expr } from '../types';
-import { ComputeCtx } from './compute-ctx';
-export declare const includeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
-export declare const excludeElementRef: (ctx: ComputeCtx, expr: Expr.ElementRefExpr) => ComputeCtx;
-export declare const includeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
-export declare const excludeElementKindOrTag: (ctx: ComputeCtx, expr: Expr.ElementKindExpr | Expr.ElementTagExpr) => ComputeCtx;
-export declare const includeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
-export declare const excludeWildcardRef: (ctx: ComputeCtx, _expr: Expr.WildcardExpr) => ComputeCtx;
-export declare const includeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
-export declare const excludeIncomingExpr: (ctx: ComputeCtx, expr: Expr.IncomingExpr) => ComputeCtx;
-export declare const includeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
-export declare const excludeOutgoingExpr: (ctx: ComputeCtx, expr: Expr.OutgoingExpr) => ComputeCtx;
-export declare const includeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
-export declare const excludeInOutExpr: (ctx: ComputeCtx, expr: Expr.InOutExpr) => ComputeCtx;
-export declare const includeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;
-export declare const excludeRelationExpr: (ctx: ComputeCtx, expr: Expr.RelationExpr) => ComputeCtx;

package/dist/compute-view/compute-predicates.js

@@ -1,324 +0,0 @@
-import { anyPass, both, either, isNil, uniq } from "rambdax";
-import { Expr } from "../types/index.js";
-import { commonAncestor, isAncestor, isSameHierarchy, Relations } from "../utils/index.js";
-import { ComputeCtx } from "./compute-ctx.js";
-const { isAnyInOut, isBetween, isIncoming, isInside, isOutgoing, isAnyBetween } = Relations;
-export const includeElementRef = (ctx, expr) => {
-  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const filters = [];
-  if (expr.isDescedants) {
-    elements.forEach((child) => {
-      filters.push(both(isInside(expr.element), isAnyInOut(child.id)));
-    });
-  }
-  const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
-  const excludeImplicits = [];
-  for (const el of elements) {
-    if (ctx.root && ctx.root !== el.id && !isAncestor(el.id, ctx.root)) {
-      excludeImplicits.push(...[...ctx.implicits].filter((impl) => isAncestor(el.id, impl.id)));
-    }
-    for (const ctxEl of ctxElements) {
-      if (!isSameHierarchy(el, ctxEl)) {
-        filters.push(isAnyBetween(el.id, ctxEl.id));
-      }
-    }
-  }
-  const relations = filters.length ? ctx.index.filterRelations(anyPass(filters)) : [];
-  if (excludeImplicits.length == 0) {
-    return ctx.include({ elements, relations });
-  }
-  return ctx.include({ elements, relations }).exclude({ implicits: excludeImplicits });
-};
-export const excludeElementRef = (ctx, expr) => {
-  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const elementsIds = elements.map((e) => e.id);
-  const relations = [...ctx.relations].filter(
-    (r) => elementsIds.includes(r.source) || elementsIds.includes(r.target)
-  );
-  return ctx.exclude({ elements, relations });
-};
-const asElementPredicate = (expr) => {
-  if (expr.isEqual) {
-    if (Expr.isElementKindExpr(expr)) {
-      return (e) => e.kind === expr.elementKind;
-    } else {
-      return ({ tags }) => !!tags && tags.includes(expr.elementTag);
-    }
-  } else {
-    if (Expr.isElementKindExpr(expr)) {
-      return (e) => e.kind !== expr.elementKind;
-    } else {
-      return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    }
-  }
-};
-export const includeElementKindOrTag = (ctx, expr) => {
-  const elements = ctx.index.elements.filter(asElementPredicate(expr));
-  return elements.reduce(
-    (accCtx, el) => includeElementRef(accCtx, {
-      element: el.id,
-      isDescedants: false
-    }),
-    ctx
-  );
-};
-export const excludeElementKindOrTag = (ctx, expr) => {
-  const predicate = asElementPredicate(expr);
-  const elements = [...ctx.elements].filter(predicate);
-  const implicits = [...ctx.implicits].filter(predicate);
-  return ctx.exclude({ elements, implicits });
-};
-export const includeWildcardRef = (ctx, _expr) => {
-  const { root } = ctx;
-  if (root) {
-    const elements = [ctx.index.find(root), ...ctx.index.children(root)];
-    const allImplicits = [
-      ...ctx.index.siblings(root),
-      ...ctx.index.ancestors(root).flatMap((a) => [...ctx.index.siblings(a.id)])
-    ];
-    const inOut = ctx.index.filterRelations(isAnyInOut(root));
-    const implicits = [];
-    for (const implicit of allImplicits) {
-      if (inOut.some(isAnyInOut(implicit.id))) {
-        implicits.push(implicit);
-      }
-    }
-    return ctx.include({
-      elements,
-      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
-      implicits
-    });
-  } else {
-    const elements = ctx.index.rootElements();
-    if (elements.length <= 1) {
-      return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
-    }
-    const relations = ctx.index.filterRelations(
-      (rel) => isNil(commonAncestor(rel.source, rel.target))
-    );
-    return ctx.include({
-      elements,
-      relations
-    });
-  }
-};
-export const excludeWildcardRef = (ctx, _expr) => {
-  const { root } = ctx;
-  if (root) {
-    const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
-    return ctx.exclude({
-      elements: [...ctx.elements].filter((e) => e.id === root || isAncestor(root, e.id)),
-      relations,
-      implicits: [...ctx.implicits].filter((e) => relations.some(isAnyInOut(e.id)))
-    });
-  } else {
-    return new ComputeCtx(ctx.index, ctx.root);
-  }
-};
-const resolveElements = (ctx, expr) => {
-  if (Expr.isWildcard(expr)) {
-    if (ctx.root) {
-      return [ctx.index.find(ctx.root)];
-    } else {
-      return ctx.index.rootElements();
-    }
-  }
-  if (Expr.isElementKindExpr(expr)) {
-    return ctx.index.elements.filter((el) => {
-      if (expr.isEqual) {
-        return el.kind === expr.elementKind;
-      }
-      return el.kind !== expr.elementKind;
-    });
-  }
-  if (Expr.isElementTagExpr(expr)) {
-    return ctx.index.elements.filter((el) => {
-      const tags = el.tags;
-      if (expr.isEqual) {
-        return !!tags && tags.includes(expr.elementTag);
-      }
-      return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    });
-  }
-  if (expr.isDescedants) {
-    return ctx.index.children(expr.element);
-  } else {
-    return [ctx.index.find(expr.element)];
-  }
-};
-export const includeIncomingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.incoming)) {
-    allrelations = allrelations.filter(isIncoming(expr.incoming.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isIncoming(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeIncomingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isIncomings = anyPass(elements.map((el) => isIncoming(el.id)));
-  const excluded = [...ctx.relations].filter(isIncomings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeOutgoingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.outgoing)) {
-    allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isOutgoing(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeOutgoingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isOutgoings = anyPass(elements.map((el) => isOutgoing(el.id)));
-  const excluded = [...ctx.relations].filter(isOutgoings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeInOutExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.inout)) {
-    allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const target of targets) {
-    const foundRelations = allrelations.filter(isAnyInOut(target.id));
-    if (foundRelations.length > 0) {
-      relations.push(...foundRelations);
-      implicits.push(target);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeInOutExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter(anyPass(targets.map((t) => isAnyInOut(t.id))));
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  if (sources.length === 0 || targets.length === 0) {
-    return ctx;
-  }
-  const implicits = [];
-  const relations = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if (isSameHierarchy(source, target)) {
-        continue;
-      }
-      const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
-      if (foundRelations.length > 0) {
-        relations.push(...foundRelations);
-        implicits.push(source, target);
-      }
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  const filters = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if (isSameHierarchy(source, target)) {
-        continue;
-      }
-      filters.push(isBetween(source.id, target.id));
-    }
-  }
-  if (filters.length == 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter(anyPass(filters));
-  if (excluded.length == 0) {
-    return ctx;
-  }
-  return ctx.exclude({
-    relations: excluded
-  });
-};