@likec4/core 1.48.0 → 1.50.0

package/dist/_chunks/expression-model.mjs

@@ -1,103 +0,0 @@
-import { t as FqnRef } from "./fqnRef.mjs";
-
-//#region src/types/expression-model.ts
-let ModelFqnExpr;
-(function(_ModelFqnExpr) {
-	function isWildcard(expr) {
-		return "wildcard" in expr && expr.wildcard === true;
-	}
-	_ModelFqnExpr.isWildcard = isWildcard;
-	function isModelRef(ref) {
-		return "ref" in ref && FqnRef.isModelRef(ref.ref);
-	}
-	_ModelFqnExpr.isModelRef = isModelRef;
-	function isElementKindExpr(expr) {
-		return "elementKind" in expr && "isEqual" in expr;
-	}
-	_ModelFqnExpr.isElementKindExpr = isElementKindExpr;
-	function isElementTagExpr(expr) {
-		return "elementTag" in expr && "isEqual" in expr;
-	}
-	_ModelFqnExpr.isElementTagExpr = isElementTagExpr;
-	function isWhere(expr) {
-		return "where" in expr && is(expr.where.expr);
-	}
-	_ModelFqnExpr.isWhere = isWhere;
-	function isCustom(expr) {
-		return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
-	}
-	_ModelFqnExpr.isCustom = isCustom;
-	function is(expr) {
-		return isWildcard(expr) || isModelRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
-	}
-	_ModelFqnExpr.is = is;
-	function unwrap(expr) {
-		if (isCustom(expr)) expr = expr.custom.expr;
-		if (isWhere(expr)) expr = expr.where.expr;
-		return expr;
-	}
-	_ModelFqnExpr.unwrap = unwrap;
-})(ModelFqnExpr || (ModelFqnExpr = {}));
-let ModelRelationExpr;
-(function(_ModelRelationExpr) {
-	function isDirect(expr) {
-		return "source" in expr && "target" in expr;
-	}
-	_ModelRelationExpr.isDirect = isDirect;
-	function isIncoming(expr) {
-		return "incoming" in expr;
-	}
-	_ModelRelationExpr.isIncoming = isIncoming;
-	function isOutgoing(expr) {
-		return "outgoing" in expr;
-	}
-	_ModelRelationExpr.isOutgoing = isOutgoing;
-	function isInOut(expr) {
-		return "inout" in expr;
-	}
-	_ModelRelationExpr.isInOut = isInOut;
-	function isWhere(expr) {
-		return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
-	}
-	_ModelRelationExpr.isWhere = isWhere;
-	function isCustom(expr) {
-		return "customRelation" in expr;
-	}
-	_ModelRelationExpr.isCustom = isCustom;
-	function is(expr) {
-		return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
-	}
-	_ModelRelationExpr.is = is;
-	function unwrap(expr) {
-		if (isCustom(expr)) expr = expr.customRelation.expr;
-		if (isWhere(expr)) expr = expr.where.expr;
-		return expr;
-	}
-	_ModelRelationExpr.unwrap = unwrap;
-})(ModelRelationExpr || (ModelRelationExpr = {}));
-let ModelExpression;
-(function(_ModelExpression) {
-	function isWhere(expr) {
-		return "where" in expr;
-	}
-	_ModelExpression.isWhere = isWhere;
-	function isRelationWhere(expr) {
-		return ModelRelationExpr.isWhere(expr);
-	}
-	_ModelExpression.isRelationWhere = isRelationWhere;
-	function isFqnExprWhere(expr) {
-		return ModelFqnExpr.isWhere(expr);
-	}
-	_ModelExpression.isFqnExprWhere = isFqnExprWhere;
-	function isFqnExpr(expr) {
-		return ModelFqnExpr.is(expr) || ModelFqnExpr.isWhere(expr) || ModelFqnExpr.isCustom(expr);
-	}
-	_ModelExpression.isFqnExpr = isFqnExpr;
-	function isRelationExpr(expr) {
-		return ModelRelationExpr.is(expr) || ModelRelationExpr.isWhere(expr) || ModelRelationExpr.isCustom(expr);
-	}
-	_ModelExpression.isRelationExpr = isRelationExpr;
-})(ModelExpression || (ModelExpression = {}));
-
-//#endregion
-export { ModelFqnExpr as n, ModelRelationExpr as r, ModelExpression as t };

package/dist/_chunks/expression.d.mts

@@ -1,347 +0,0 @@
-import { H as StrictViewId, U as Tag, W as Tags, m as ElementKind, n as Any, t as AllKinds, vt as ExclusiveUnion, wt as NonEmptyArray } from "./_aux.mjs";
-import { f as MarkdownOrString, u as Icon } from "./scalar.mjs";
-import { t as FqnRef } from "./fqnRef.mjs";
-import { Tagged, TupleToUnion } from "type-fest";
-
-//#region ../../styled-system/preset/src/defaults/types.d.ts
-declare const Sizes: readonly ["xs", "sm", "md", "lg", "xl"];
-declare const IconPositions: readonly ["left", "right", "top", "bottom"];
-declare const BorderStyles: readonly ["solid", "dashed", "dotted", "none"];
-declare const ElementShapes: readonly ["rectangle", "person", "browser", "mobile", "cylinder", "storage", "queue", "bucket", "document"];
-declare const ThemeColors: readonly ["amber", "blue", "gray", "slate", "green", "indigo", "muted", "primary", "red", "secondary", "sky"];
-declare const DefaultTagColors: readonly ["tomato", "grass", "blue", "ruby", "orange", "indigo", "pink", "teal", "purple", "amber", "crimson", "red", "lime", "yellow", "violet"];
-//#endregion
-//#region src/styles/types.d.ts
-/**
- * For padding, margin, etc.
- */
-type Size = typeof Sizes[number];
-type TextSize = Size;
-type ShapeSize = Size;
-type SpacingSize = Size;
-type IconSize = Size;
-type IconPosition = typeof IconPositions[number];
-type BorderStyle = typeof BorderStyles[number];
-type ElementShape = typeof ElementShapes[number];
-type HexColor = `#${string}`;
-type ColorLiteral = HexColor | `rgb(${number},${number},${number})` | `rgba(${number},${number},${number},${number})`;
-type RelationshipLineType = 'dashed' | 'solid' | 'dotted';
-declare const RelationshipArrowTypes: readonly ["none", "normal", "onormal", "dot", "odot", "diamond", "odiamond", "crow", "open", "vee"];
-type RelationshipArrowType = TupleToUnion<typeof RelationshipArrowTypes>;
-type ThemeColor = typeof ThemeColors[number];
-declare function isThemeColor(color: string): color is ThemeColor;
-type CustomColorDefinitions = {
-  [key: string]: ThemeColorValues;
-};
-type CustomColor = Tagged<string, 'CustomColor'>;
-declare function isCustomColor(color: string): color is CustomColor;
-type Color = ThemeColor | CustomColor;
-interface ElementColorValues {
-  readonly fill: ColorLiteral;
-  readonly stroke: ColorLiteral;
-  readonly hiContrast: ColorLiteral;
-  readonly loContrast: ColorLiteral;
-}
-interface RelationshipColorValues {
-  readonly line: ColorLiteral;
-  readonly labelBg: ColorLiteral;
-  readonly label: ColorLiteral;
-}
-interface ThemeColorValues {
-  readonly elements: ElementColorValues;
-  readonly relationships: RelationshipColorValues;
-}
-/**
- * Default style values for elements, groups and relationships
- */
-interface LikeC4StyleDefaults {
-  readonly color: ThemeColor;
-  readonly size: ShapeSize;
-  readonly shape: ElementShape;
-  readonly opacity?: number;
-  readonly border?: BorderStyle;
-  readonly padding?: SpacingSize;
-  readonly text?: TextSize;
-  readonly iconPosition?: IconPosition;
-  /**
-   * Default style values for groups
-   * If not specified, the default values for elements are used
-   */
-  readonly group?: {
-    readonly color?: ThemeColor;
-    readonly opacity?: number;
-    readonly border?: BorderStyle;
-  };
-  readonly relationship: {
-    readonly color: ThemeColor;
-    readonly line: RelationshipLineType;
-    readonly arrow: RelationshipArrowType;
-  };
-}
-interface LikeC4Theme {
-  readonly colors: Readonly<Record<ThemeColor, ThemeColorValues>>;
-  readonly sizes: Readonly<Record<ShapeSize, {
-    readonly width: number;
-    readonly height: number;
-  }>>;
-  readonly spacing: Readonly<Record<SpacingSize, number>>;
-  readonly textSizes: Readonly<Record<TextSize, number>>;
-  readonly iconSizes: Readonly<Record<IconSize, number>>;
-}
-interface LikeC4StylesConfig {
-  readonly theme: LikeC4Theme;
-  readonly defaults: LikeC4StyleDefaults;
-}
-//#endregion
-//#region src/types/operators.d.ts
-type EqualOperator<V> = {
-  eq: V;
-  neq?: never;
-} | {
-  eq?: never;
-  neq: V;
-};
-type AllNever = {
-  not?: never;
-  and?: never;
-  or?: never;
-  tag?: never;
-  kind?: never;
-  participant?: never;
-  operator?: never;
-};
-type TagEqual<A extends Any> = Omit<AllNever, 'tag'> & {
-  tag: EqualOperator<Tag<A>> | Tag<A>;
-};
-declare function isTagEqual<A extends Any>(operator: WhereOperator<A>): operator is TagEqual<A>;
-type KindEqual<A extends Any> = Omit<AllNever, 'kind'> & {
-  kind: EqualOperator<AllKinds<A>> | AllKinds<A>;
-};
-declare function isKindEqual<A extends Any>(operator: WhereOperator<A>): operator is KindEqual<A>;
-type Participant = 'source' | 'target';
-type ParticipantOperator<A extends Any> = Omit<AllNever, 'participant' | 'operator'> & {
-  participant: Participant;
-  operator: KindEqual<A> | TagEqual<A>;
-};
-declare function isParticipantOperator<A extends Any>(operator: WhereOperator<A>): operator is ParticipantOperator<A>;
-type NotOperator<A extends Any> = Omit<AllNever, 'not'> & {
-  not: WhereOperator<A>;
-};
-declare function isNotOperator<A extends Any>(operator: WhereOperator<A>): operator is NotOperator<A>;
-type AndOperator<A extends Any> = Omit<AllNever, 'and'> & {
-  and: NonEmptyArray<WhereOperator<A>>;
-};
-declare function isAndOperator<A extends Any>(operator: WhereOperator<A>): operator is AndOperator<A>;
-type OrOperator<A extends Any> = Omit<AllNever, 'or'> & {
-  or: NonEmptyArray<WhereOperator<A>>;
-};
-declare function isOrOperator<A extends Any>(operator: WhereOperator<A>): operator is OrOperator<A>;
-type WhereOperator<A extends Any = Any> = TagEqual<A> | KindEqual<A> | ParticipantOperator<A> | NotOperator<A> | AndOperator<A> | OrOperator<A>;
-type Filterable<A extends Any> = {
-  tags?: Tags<A> | null | undefined;
-  kind?: AllKinds<A> | null | undefined;
-  source?: Filterable<A>;
-  target?: Filterable<A>;
-};
-type OperatorPredicate<A extends Any> = (value: Filterable<A>) => boolean;
-declare function whereOperatorAsPredicate<A extends Any>(operator: WhereOperator<A>): OperatorPredicate<A>;
-//#endregion
-//#region src/types/expression.d.ts
-type AnyAux = Any;
-type PredicateSelector = 'children' | 'expanded' | 'descendants';
-declare namespace FqnExpr {
-  type Wildcard = {
-    wildcard: true;
-  };
-  function isWildcard<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Wildcard;
-  interface ModelRef<M extends AnyAux = AnyAux> {
-    ref: FqnRef.ModelRef<M>;
-    selector?: PredicateSelector;
-  }
-  function isModelRef<A extends AnyAux>(ref: Expression<A>): ref is FqnExpr.ModelRef<A>;
-  interface DeploymentRef<A extends AnyAux = AnyAux> {
-    ref: FqnRef.DeploymentRef<A>;
-    selector?: PredicateSelector;
-  }
-  function isDeploymentRef<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.DeploymentRef<A>;
-  interface ElementKindExpr<A extends AnyAux = AnyAux> {
-    elementKind: ElementKind<A>;
-    isEqual: boolean;
-  }
-  function isElementKindExpr<A extends AnyAux>(expr: Expression<A>): expr is ElementKindExpr<A>;
-  interface ElementTagExpr<A extends AnyAux = AnyAux> {
-    elementTag: Tag<A>;
-    isEqual: boolean;
-  }
-  function isElementTagExpr<A extends AnyAux>(expr: Expression<A>): expr is ElementTagExpr<A>;
-  type NonWildcard<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    ModelRef: ModelRef<A>;
-    DeploymentRef: DeploymentRef<A>;
-    ElementKind: ElementKindExpr<A>;
-    ElementTag: ElementTagExpr<A>;
-  }>;
-  interface Where<A extends AnyAux = AnyAux> {
-    where: {
-      expr: ExclusiveUnion<{
-        Wildcard: Wildcard;
-        ModelRef: ModelRef<A>;
-        DeploymentRef: DeploymentRef<A>;
-        ElementKind: ElementKindExpr<A>;
-        ElementTag: ElementTagExpr<A>;
-      }>;
-      condition: WhereOperator<A>;
-    };
-  }
-  function isWhere<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Where<A>;
-  interface Custom<A extends AnyAux = AnyAux> {
-    custom: {
-      expr: OrWhere<A>;
-      title?: string;
-      description?: MarkdownOrString;
-      technology?: string;
-      notation?: string;
-      shape?: ElementShape;
-      color?: Color;
-      icon?: Icon;
-      iconColor?: Color;
-      iconSize?: ShapeSize;
-      iconPosition?: IconPosition;
-      border?: BorderStyle;
-      opacity?: number;
-      navigateTo?: StrictViewId<A>;
-      multiple?: boolean;
-      size?: ShapeSize;
-      padding?: ShapeSize;
-      textSize?: ShapeSize;
-    };
-  }
-  function isCustom<A extends AnyAux>(expr: Expression<A>): expr is Custom<A>;
-  function is<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr<A>;
-  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Wildcard: FqnExpr.Wildcard;
-    ModelRef: FqnExpr.ModelRef<A>;
-    DeploymentRef: FqnExpr.DeploymentRef<A>;
-    ElementKind: ElementKindExpr<A>;
-    ElementTag: ElementTagExpr<A>;
-    Where: FqnExpr.Where<A>;
-  }>;
-  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Wildcard: Wildcard;
-    ModelRef: ModelRef<A>;
-    DeploymentRef: DeploymentRef<A>;
-    ElementKind: ElementKindExpr<A>;
-    ElementTag: ElementTagExpr<A>;
-    Where: Where<A>;
-    Custom: Custom<A>;
-  }>;
-  function unwrap<A extends AnyAux>(expr: FqnExpr.Any<A>): Wildcard | ModelRef<A> | DeploymentRef<A> | ElementKindExpr<A> | ElementTagExpr<A>;
-}
-type FqnExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-  Wildcard: FqnExpr.Wildcard;
-  ModelRef: FqnExpr.ModelRef<A>;
-  DeploymentRef: FqnExpr.DeploymentRef<A>;
-  ElementKind: FqnExpr.ElementKindExpr<A>;
-  ElementTag: FqnExpr.ElementTagExpr<A>;
-}>;
-declare namespace RelationExpr {
-  type Endpoint<A extends AnyAux = AnyAux> = FqnExpr.Where<A>['where']['expr'];
-  interface Direct<A extends AnyAux = AnyAux> {
-    source: Endpoint<A>;
-    target: Endpoint<A>;
-    isBidirectional?: boolean;
-  }
-  function isDirect<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Direct<A>;
-  interface Incoming<A extends AnyAux = AnyAux> {
-    incoming: Endpoint<A>;
-  }
-  function isIncoming<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Incoming<A>;
-  interface Outgoing<A extends AnyAux = AnyAux> {
-    outgoing: Endpoint<A>;
-  }
-  function isOutgoing<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Outgoing<A>;
-  interface InOut<A extends AnyAux = AnyAux> {
-    inout: Endpoint<A>;
-  }
-  function isInOut<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.InOut<A>;
-  interface Where<A extends AnyAux = AnyAux> {
-    where: {
-      expr: ExclusiveUnion<{
-        Direct: RelationExpr.Direct<A>;
-        Incoming: RelationExpr.Incoming<A>;
-        Outgoing: RelationExpr.Outgoing<A>;
-        InOut: RelationExpr.InOut<A>;
-      }>;
-      condition: WhereOperator<A>;
-    };
-  }
-  function isWhere<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Where<A>;
-  interface Custom<A extends AnyAux = AnyAux> {
-    customRelation: {
-      expr: OrWhere<A>;
-      title?: string;
-      description?: string;
-      technology?: string;
-      notation?: string;
-      navigateTo?: StrictViewId<A>;
-      notes?: string;
-      color?: Color;
-      line?: RelationshipLineType;
-      head?: RelationshipArrowType;
-      tail?: RelationshipArrowType;
-    };
-  }
-  function isCustom<A extends AnyAux>(expr: Expression<A>): expr is Custom<A>;
-  function is<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr<A>;
-  type OrWhere<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Direct: Direct<A>;
-    Incoming: Incoming<A>;
-    Outgoing: Outgoing<A>;
-    InOut: InOut<A>;
-    Where: Where<A>;
-  }>;
-  type Any<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-    Direct: Direct<A>;
-    Incoming: Incoming<A>;
-    Outgoing: Outgoing<A>;
-    InOut: InOut<A>;
-    Where: Where<A>;
-    Custom: Custom<A>;
-  }>;
-  function unwrap<A extends AnyAux>(expr: RelationExpr.Any<A>): Direct<A> | Incoming<A> | Outgoing<A> | InOut<A>;
-}
-type RelationExpr<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-  Direct: RelationExpr.Direct<A>;
-  Incoming: RelationExpr.Incoming<A>;
-  Outgoing: RelationExpr.Outgoing<A>;
-  InOut: RelationExpr.InOut<A>;
-}>;
-/**
- * Represents a version 2 expression which can be one of several types.
- *
- * @template D - The type for the deployment FQN, defaults to `Fqn`.
- * @template M - The type for the model FQN, defaults to `Fqn`.
- */
-type Expression<A extends AnyAux = AnyAux> = ExclusiveUnion<{
-  Wildcard: FqnExpr.Wildcard;
-  ModelRef: FqnExpr.ModelRef<A>;
-  DeploymentRef: FqnExpr.DeploymentRef<A>;
-  ElementKind: FqnExpr.ElementKindExpr<A>;
-  ElementTag: FqnExpr.ElementTagExpr<A>;
-  Custom: FqnExpr.Custom<A>;
-  Direct: RelationExpr.Direct<A>;
-  Incoming: RelationExpr.Incoming<A>;
-  Outgoing: RelationExpr.Outgoing<A>;
-  InOut: RelationExpr.InOut<A>;
-  Where: Expression.Where<A>;
-  CustomRelation: RelationExpr.Custom<A>;
-}>;
-declare namespace Expression {
-  type Where<A extends AnyAux = AnyAux> = FqnExpr.Where<A> | RelationExpr.Where<A>;
-  function isWhere<A extends AnyAux>(expr: Expression<A>): expr is Expression.Where<A>;
-  function isRelationWhere<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Where<A>;
-  function isFqnExprWhere<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Where<A>;
-  function isFqnExpr<A extends AnyAux>(expr: Expression<A>): expr is FqnExpr.Any<A>;
-  function isRelation<A extends AnyAux>(expr: Expression<A>): expr is RelationExpr.Any<A>;
-}
-//#endregion
-export { ThemeColors as $, HexColor as A, ShapeSize as B, BorderStyle as C, CustomColorDefinitions as D, CustomColor as E, LikeC4Theme as F, ThemeColorValues as G, SpacingSize as H, RelationshipArrowType as I, BorderStyles as J, isCustomColor as K, RelationshipArrowTypes as L, IconSize as M, LikeC4StyleDefaults as N, ElementColorValues as O, LikeC4StylesConfig as P, Sizes as Q, RelationshipColorValues as R, whereOperatorAsPredicate as S, ColorLiteral as T, TextSize as U, Size as V, ThemeColor as W, ElementShapes as X, DefaultTagColors as Y, IconPositions as Z, isKindEqual as _, AndOperator as a, isParticipantOperator as b, KindEqual as c, OrOperator as d, Participant as f, isAndOperator as g, WhereOperator as h, RelationExpr as i, IconPosition as j, ElementShape as k, NotOperator as l, TagEqual as m, FqnExpr as n, EqualOperator as o, ParticipantOperator as p, isThemeColor as q, PredicateSelector as r, Filterable as s, Expression as t, OperatorPredicate as u, isNotOperator as v, Color as w, isTagEqual as x, isOrOperator as y, RelationshipLineType as z };

package/dist/_chunks/expression.mjs

@@ -1,107 +0,0 @@
-import { t as FqnRef } from "./fqnRef.mjs";
-
-//#region src/types/expression.ts
-let FqnExpr;
-(function(_FqnExpr) {
-	function isWildcard(expr) {
-		return "wildcard" in expr && expr.wildcard === true;
-	}
-	_FqnExpr.isWildcard = isWildcard;
-	function isModelRef(ref) {
-		return "ref" in ref && FqnRef.isModelRef(ref.ref);
-	}
-	_FqnExpr.isModelRef = isModelRef;
-	function isDeploymentRef(expr) {
-		return "ref" in expr && FqnRef.isDeploymentRef(expr.ref);
-	}
-	_FqnExpr.isDeploymentRef = isDeploymentRef;
-	function isElementKindExpr(expr) {
-		return "elementKind" in expr && "isEqual" in expr;
-	}
-	_FqnExpr.isElementKindExpr = isElementKindExpr;
-	function isElementTagExpr(expr) {
-		return "elementTag" in expr && "isEqual" in expr;
-	}
-	_FqnExpr.isElementTagExpr = isElementTagExpr;
-	function isWhere(expr) {
-		return "where" in expr && is(expr.where.expr);
-	}
-	_FqnExpr.isWhere = isWhere;
-	function isCustom(expr) {
-		return "custom" in expr && (is(expr.custom.expr) || isWhere(expr.custom.expr));
-	}
-	_FqnExpr.isCustom = isCustom;
-	function is(expr) {
-		return isWildcard(expr) || isModelRef(expr) || isDeploymentRef(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
-	}
-	_FqnExpr.is = is;
-	function unwrap(expr) {
-		if (isCustom(expr)) expr = expr.custom.expr;
-		if (isWhere(expr)) expr = expr.where.expr;
-		return expr;
-	}
-	_FqnExpr.unwrap = unwrap;
-})(FqnExpr || (FqnExpr = {}));
-let RelationExpr;
-(function(_RelationExpr) {
-	function isDirect(expr) {
-		return "source" in expr && "target" in expr;
-	}
-	_RelationExpr.isDirect = isDirect;
-	function isIncoming(expr) {
-		return "incoming" in expr;
-	}
-	_RelationExpr.isIncoming = isIncoming;
-	function isOutgoing(expr) {
-		return "outgoing" in expr;
-	}
-	_RelationExpr.isOutgoing = isOutgoing;
-	function isInOut(expr) {
-		return "inout" in expr;
-	}
-	_RelationExpr.isInOut = isInOut;
-	function isWhere(expr) {
-		return "where" in expr && (isDirect(expr.where.expr) || isIncoming(expr.where.expr) || isOutgoing(expr.where.expr) || isInOut(expr.where.expr));
-	}
-	_RelationExpr.isWhere = isWhere;
-	function isCustom(expr) {
-		return "customRelation" in expr;
-	}
-	_RelationExpr.isCustom = isCustom;
-	function is(expr) {
-		return isDirect(expr) || isIncoming(expr) || isOutgoing(expr) || isInOut(expr);
-	}
-	_RelationExpr.is = is;
-	function unwrap(expr) {
-		if (isCustom(expr)) expr = expr.customRelation.expr;
-		if (isWhere(expr)) expr = expr.where.expr;
-		return expr;
-	}
-	_RelationExpr.unwrap = unwrap;
-})(RelationExpr || (RelationExpr = {}));
-let Expression;
-(function(_Expression) {
-	function isWhere(expr) {
-		return "where" in expr;
-	}
-	_Expression.isWhere = isWhere;
-	function isRelationWhere(expr) {
-		return RelationExpr.isWhere(expr);
-	}
-	_Expression.isRelationWhere = isRelationWhere;
-	function isFqnExprWhere(expr) {
-		return FqnExpr.isWhere(expr);
-	}
-	_Expression.isFqnExprWhere = isFqnExprWhere;
-	function isFqnExpr(expr) {
-		return FqnExpr.is(expr) || FqnExpr.isWhere(expr) || FqnExpr.isCustom(expr);
-	}
-	_Expression.isFqnExpr = isFqnExpr;
-	function isRelation(expr) {
-		return RelationExpr.is(expr) || RelationExpr.isWhere(expr) || RelationExpr.isCustom(expr);
-	}
-	_Expression.isRelation = isRelation;
-})(Expression || (Expression = {}));
-
-//#endregion
-export { FqnExpr as n, RelationExpr as r, Expression as t };

package/dist/_chunks/find.d.mts

@@ -1,82 +0,0 @@
-import { bt as IteratorLike, f as EdgeId, n as Any } from "./_aux.mjs";
-import { T as RelationshipModel, a as DeploymentNodeModel, i as DeploymentElementModel, l as RelationshipsAccum, s as DeploymentRelationModel } from "./LikeC4Model.mjs";
-import { n as Connection, t as customInspectSymbol } from "./const.mjs";
-
-//#region src/model/connection/deployment/DeploymentConnectionModel.d.ts
-/**
- * Connection is ephemeral entity, result of a resolving relationships between source and target.
- * Includes direct relationships and/or between their nested elements.
- */
-declare class DeploymentConnectionModel<A extends Any = Any> implements Connection<DeploymentElementModel<A>, EdgeId> {
-  readonly source: DeploymentElementModel<A>;
-  readonly target: DeploymentElementModel<A>;
-  readonly relations: RelationshipsAccum<A>;
-  readonly id: EdgeId;
-  constructor(source: DeploymentElementModel<A>, target: DeploymentElementModel<A>, relations: RelationshipsAccum<A>);
-  /**
-   * Human readable expression of the connection
-   * Mostly used for testing and debugging
-   */
-  get expression(): string;
-  private _boundary;
-  /**
-   * Common ancestor of the source and target elements.
-   * Represents the boundary of the connection.
-   */
-  get boundary(): DeploymentNodeModel<A> | null;
-  nonEmpty(): boolean;
-  [customInspectSymbol](_depth: any, _inspectOptions: any, _inspect: any): string;
-  toString(): string;
-  /**
-   * Check if connection contains deployment relation,
-   * that is directly connected to source or target.
-   */
-  hasDirectDeploymentRelation(): boolean;
-  values(): IteratorLike<RelationshipModel<A> | DeploymentRelationModel<A>>;
-  /**
-   * Merge with another connections, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
-  mergeWith(others: DeploymentConnectionModel<A>[]): DeploymentConnectionModel<A>;
-  /**
-   * Merge with another connection, if it has the same source and target.
-   * Returns new connection with union of relationships.
-   */
-  mergeWith(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
-  difference(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
-  intersect(other: DeploymentConnectionModel<A>): DeploymentConnectionModel<A>;
-  equals(other: Connection): boolean;
-  /**
-   * Creates a clone of the current `DeploymentConnectionModel` instance with optional overrides.
-   * if `null` is provided in overrides, the corresponding relation set will be empty.
-   */
-  update(overrides?: {
-    model?: ReadonlySet<RelationshipModel<A>> | null;
-    deployment?: ReadonlySet<DeploymentRelationModel<A>> | null;
-  }): DeploymentConnectionModel<A>;
-}
-declare namespace find_d_exports {
-  export { findConnection, findConnectionsBetween, findConnectionsWithin };
-}
-/**
- * Resolve connection from source to target
- * If direction is `both`, also look for reverse connection
- *
- * @default direction directed
- */
-declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'directed'): readonly [DeploymentConnectionModel<M>] | readonly [];
-declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction: 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
-declare function findConnection<M extends Any>(source: DeploymentElementModel<M>, target: DeploymentElementModel<NoInfer<M>>, direction?: 'directed' | 'both'): readonly [DeploymentConnectionModel<M>, DeploymentConnectionModel<M>] | readonly [DeploymentConnectionModel<M>] | readonly [];
-/**
- * Resolve all connections between element and others
- * By default, look for both directions.
- *
- * @default direction both
- */
-declare function findConnectionsBetween<M extends Any>(element: DeploymentElementModel<M>, others: Iterable<DeploymentElementModel<NoInfer<M>>>, direction?: 'directed' | 'both'): readonly DeploymentConnectionModel<M>[];
-/**
- * Resolve all connections within a given set of elements
- */
-declare function findConnectionsWithin<M extends Any>(elements: Iterable<DeploymentElementModel<M>>): readonly DeploymentConnectionModel<M>[];
-//#endregion
-export { DeploymentConnectionModel as a, find_d_exports as i, findConnectionsBetween as n, findConnectionsWithin as r, findConnection as t };