@likec4/core 1.46.4 → 1.48.0

package/dist/compute-view/index.d.mts

@@ -1,45 +1,108 @@
-import { A as Any, t as toComputed, d as AnyParsed } from '../shared/core.D00YbOhQ.mjs';
-import { f as LikeC4Model } from '../shared/core.C-Jdx7xo.mjs';
-import { P as ParsedLikeC4ModelData, C as ComputedLikeC4ModelData, p as ParsedView, r as ComputedView } from '../shared/core.Ctj2S3bD.mjs';
-import 'type-fest';
-import '../shared/core.DB0Ue5Wx.mjs';
-import '../shared/core.C_3y3eqV.mjs';
-import '../shared/core.DeDCYTDR.mjs';
-import '../shared/core.BvPm_-u3.mjs';
-import '../types/fqnRef.mjs';
-import '../shared/core.DpKY_3NF.mjs';
-import '../types/expression-model.mjs';
-import '../shared/core.BPGOjone.mjs';
-import '../shared/core.CywrQs86.mjs';
+import { ct as toComputed, ht as _type, mt as _stage, n as Any, o as AnyParsed, wt as NonEmptyArray } from "../_chunks/_aux.mjs";
+import "../_chunks/scalar.mjs";
+import "../_chunks/expression.mjs";
+import "../_chunks/fqnRef.mjs";
+import { t as ModelExpression } from "../_chunks/expression-model.mjs";
+import { $t as AnyIncludePredicate, J as ComputedEdge, Qt as AnyExcludePredicate, X as ComputedNode, c as ComputedLikeC4ModelData, d as ParsedLikeC4ModelData, h as ParsedView, on as ViewAutoLayout, p as ComputedView, rn as BaseViewProperties } from "../_chunks/index2.mjs";
+import "../_chunks/RichText.mjs";
+import "../_chunks/index3.mjs";
+import { n as LikeC4Model } from "../_chunks/LikeC4Model.mjs";
+import { B as ViewPredicate } from "../_chunks/_types.mjs";
+import "../_chunks/const.mjs";
+import "../_chunks/find.mjs";
+import "../_chunks/find2.mjs";
+import "../_chunks/index4.mjs";
+import "../_chunks/index5.mjs";
+import { a as LayoutedProjectNode, i as LayoutedProjectEdge, n as ComputedProjectNode, o as LayoutedProjectsView, r as ComputedProjectsView, t as ComputedProjectEdge } from "../_chunks/_types2.mjs";
+import { n as computeRelationshipsView, r as RelationshipsViewData, t as treeFromElements } from "../_chunks/index6.mjs";
 
+//#region src/compute-view/compute-view.d.ts
 type ComputeViewResult<V> = {
-    isSuccess: true;
-    error?: undefined;
-    view: V;
+  isSuccess: true;
+  error?: undefined;
+  view: V;
 } | {
-    isSuccess: false;
-    error: Error;
-    view: undefined;
+  isSuccess: false;
+  error: Error;
+  view: undefined;
 };
 declare function unsafeComputeView<A extends Any>(viewsource: ParsedView<A>, likec4model: LikeC4Model<any>): ComputedView<A>;
 declare function computeView<A extends Any>(viewsource: ParsedView<A>, likec4model: LikeC4Model<A>): ComputeViewResult<ComputedView<A>>;
 declare function computeParsedModelData<A extends AnyParsed, B extends toComputed<A> = toComputed<A>>(parsed: ParsedLikeC4ModelData<A>): ComputedLikeC4ModelData<B>;
 declare function computeLikeC4Model<A extends Any, B extends toComputed<A> = toComputed<A>>(parsed: ParsedLikeC4ModelData<A>): LikeC4Model<B>;
-
+//#endregion
+//#region src/compute-view/utils/resolve-extended-views.d.ts
 /**
  * Resolve rules of extended views
  * (Removes invalid views)
  */
 declare function resolveRulesExtendedViews<A extends Any, V extends Record<any, ParsedView<A>>>(unresolvedViews: V): V;
-
+//#endregion
+//#region src/compute-view/utils/with-readable-edges.d.ts
 /**
  * Convert hashed edge ids to human-readable
  * Mostly for testing purposes
  */
-declare function withReadableEdges<V extends ComputedView<any>>({ edges, nodes, ...view }: V, separator?: string): V & {
-    nodeIds: string[];
-    edgeIds: string[];
+declare function withReadableEdges<V extends ComputedView<any>>({
+  edges,
+  nodes,
+  ...view
+}: V, separator?: string): V & {
+  nodeIds: string[];
+  edgeIds: string[];
 };
-declare function viewsWithReadableEdges<A extends Any>({ views, ...model }: ComputedLikeC4ModelData<A>): ComputedLikeC4ModelData<A>;
-
-export { type ComputeViewResult, computeLikeC4Model, computeParsedModelData, computeView, resolveRulesExtendedViews, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };
+declare function viewsWithReadableEdges<A extends Any>({
+  views,
+  ...model
+}: ComputedLikeC4ModelData<A>): ComputedLikeC4ModelData<A>;
+//#endregion
+//#region src/compute-view/projects-view/compute.d.ts
+/**
+ * Computes an overview of projects and their relationships
+ */
+declare function computeProjectsView(likec4models: NonEmptyArray<LikeC4Model>): ComputedProjectsView;
+//#endregion
+//#region src/compute-view/adhoc-view/compute.d.ts
+interface AdhocViewIncludePredicate<A extends Any> extends AnyIncludePredicate<ModelExpression<A>> {}
+interface AdhocViewExcludePredicate<A extends Any> extends AnyExcludePredicate<ModelExpression<A>> {}
+type AdhocViewPredicate<A extends Any = Any> = AdhocViewIncludePredicate<A> | AdhocViewExcludePredicate<A>;
+interface ComputedAdhocView extends BaseViewProperties<Any> {
+  readonly [_type]: 'adhoc';
+  readonly [_stage]: 'computed';
+  readonly nodes: ReadonlyArray<ComputedNode>;
+  readonly edges: ReadonlyArray<ComputedEdge>;
+  readonly autoLayout: ViewAutoLayout;
+}
+/**
+ * Computes an adhoc view based on the given predicates.
+ * Adhoc views are not defined in the model, but computed on demand.
+ * Available for logical model only.
+ *
+ * @param predicates accepts the same predicates as element view.
+ * @param likec4model The LikeC4 model to compute view.
+ * @returns The computed adhoc view.
+ */
+declare function computeAdhocView<A extends Any>(likec4model: LikeC4Model<A>, predicates: AdhocViewPredicate<NoInfer<A>>[]): ComputedAdhocView;
+//#endregion
+//#region src/compute-view/adhoc-view/builder.d.ts
+/**
+ * Allows you to define type-safe adhoc views using types from the model.
+ */
+declare class AdhocView<A extends Any> {
+  #private;
+  private readonly model;
+  /**
+   * Creates a new adhoc view builder.
+   */
+  static use<A extends Any>(model: LikeC4Model<A>): AdhocView<A>;
+  private constructor();
+  /**
+   * Used to cache the type of the predicates.
+   */
+  readonly Expr: ViewPredicate.AllExpression<ViewPredicate.ElementExpr<A['ElementId']>>;
+  include(...predicates: this['Expr'][]): this;
+  exclude(...predicates: this['Expr'][]): this;
+  compute(): ComputedAdhocView;
+}
+//#endregion
+export { AdhocView, type AdhocViewExcludePredicate, type AdhocViewIncludePredicate, type AdhocViewPredicate, type ComputeViewResult, type ComputedAdhocView, ComputedProjectEdge, ComputedProjectNode, ComputedProjectsView, LayoutedProjectEdge, LayoutedProjectNode, LayoutedProjectsView, type RelationshipsViewData, computeAdhocView, computeLikeC4Model, computeParsedModelData, computeProjectsView, computeRelationshipsView, computeView, resolveRulesExtendedViews, treeFromElements, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };

package/dist/compute-view/index.mjs

@@ -1,92 +1,262 @@
-import { w as willCreateCycle, t as topologicalSortExports, a as t$2, n as n$1 } from '../shared/core.xgoPk2RG.mjs';
-export { c as computeLikeC4Model, b as computeParsedModelData, d as computeView, u as unsafeComputeView } from '../shared/core.xgoPk2RG.mjs';
-import { n } from '../shared/core.BhNcrwzK.mjs';
-import { t } from '../shared/core.DVfPJPJj.mjs';
-import { r as isExtendsElementView, p as isElementView } from '../shared/core.DH7TXqXf.mjs';
-import { G as Graph } from '../shared/core.CmGY9blO.mjs';
-import { c as isNonEmptyArray } from '../shared/core.CdNCAwq7.mjs';
-import { t as t$3 } from '../shared/core.CbT8JVYL.mjs';
-import { t as t$1 } from '../shared/core.DSalPD6v.mjs';
+import { r as __toESM } from "../_chunks/rolldown-runtime.mjs";
+import { C as t$1, E as t$4, G as t$7, I as e, S as t$3, Y as t$5, Z as t$6, i as n, m as e$1, r as t, w as t$2, x as n$1, y as t$8 } from "../_chunks/libs/remeda.mjs";
+import { N as _stage, P as _type, _ as isExtendsElementView, g as isElementView } from "../_chunks/LikeC4Styles.mjs";
+import "../_chunks/libs/natural-compare-lite.mjs";
+import { N as isNonEmptyArray, r as stringHash } from "../_chunks/utils.mjs";
+import { n as nonNullable, t as invariant } from "../_chunks/invariant.mjs";
+import "../_chunks/libs/@mantine/colors-generator.mjs";
+import { n as require_topological_sort, t as require_will_create_cycle } from "../_chunks/libs/graphology-dag.mjs";
+import { n as import_default_map } from "../_chunks/libs/mnemonist.mjs";
+import "../_chunks/libs/defu.mjs";
+import "../_chunks/libs/extend.mjs";
+import { n as preferSummary } from "../_chunks/_aux.mjs";
+import { c as ProjectId, d as ViewId, i as GlobalFqn } from "../_chunks/scalar.mjs";
+import { a as unsafeComputeView, c as linkNodesWithEdges, i as computeView, n as computeLikeC4Model, o as computeElementView, r as computeParsedModelData, s as topologicalSort$1, t as $expr } from "../_chunks/Builder.view-element.mjs";
+import { t as Graph } from "../_chunks/libs/graphology.mjs";
+import { n as treeFromElements, t as computeRelationshipsView } from "../_chunks/relationships-view.mjs";
 
+//#region src/compute-view/utils/resolve-extended-views.ts
+var import_topological_sort = require_topological_sort();
+var import_will_create_cycle = /* @__PURE__ */ __toESM(require_will_create_cycle(), 1);
+/**
+* Resolve rules of extended views
+* (Removes invalid views)
+*/
 function resolveRulesExtendedViews(unresolvedViews) {
-  const g = new Graph({
-    type: "directed"
-  });
-  const extendedViews = [];
-  for (const view of t(unresolvedViews)) {
-    g.addNode(view.id, { view });
-    if (isExtendsElementView(view)) {
-      extendedViews.push(view);
-    }
-  }
-  if (extendedViews.length === 0) {
-    return unresolvedViews;
-  }
-  for (const view of extendedViews) {
-    if (!g.hasNode(view.extends)) {
-      console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`);
-      continue;
-    }
-    if (willCreateCycle(g, view.id, view.extends)) {
-      console.warn(`View "${view.id}" extends from "${view.extends}" which creates a cycle`);
-      continue;
-    }
-    g.addDirectedEdge(view.id, view.extends);
-  }
-  const sorted = topologicalSortExports.topologicalSort(g).reverse();
-  return sorted.reduce((acc, id) => {
-    const view = g.getNodeAttribute(id, "view");
-    if (!isExtendsElementView(view)) {
-      acc[view.id] = view;
-      return acc;
-    }
-    const extendsFrom = acc[view.extends];
-    if (!extendsFrom || !isElementView(extendsFrom)) {
-      return acc;
-    }
-    const tags = n([
-      ...extendsFrom.tags ?? [],
-      ...view.tags ?? []
-    ]);
-    const links = [
-      ...extendsFrom.links ?? [],
-      ...view.links ?? []
-    ];
-    acc[view.id] = {
-      ...extendsFrom,
-      ...view,
-      title: view.title ?? extendsFrom.title ?? null,
-      description: view.description ?? extendsFrom.description ?? null,
-      tags,
-      links: isNonEmptyArray(links) ? links : null,
-      rules: [...extendsFrom.rules, ...view.rules]
-    };
-    return acc;
-  }, {});
+	const g = new Graph({ type: "directed" });
+	const extendedViews = [];
+	for (const view of t(unresolvedViews)) {
+		g.addNode(view.id, { view });
+		if (isExtendsElementView(view)) extendedViews.push(view);
+	}
+	if (extendedViews.length === 0) return unresolvedViews;
+	for (const view of extendedViews) {
+		if (!g.hasNode(view.extends)) {
+			console.warn(`View "${view.id}" extends from "${view.extends}" which does not exist`);
+			continue;
+		}
+		if ((0, import_will_create_cycle.default)(g, view.id, view.extends)) {
+			console.warn(`View "${view.id}" extends from "${view.extends}" which creates a cycle`);
+			continue;
+		}
+		g.addDirectedEdge(view.id, view.extends);
+	}
+	return (0, import_topological_sort.topologicalSort)(g).reverse().reduce((acc, id) => {
+		const view = g.getNodeAttribute(id, "view");
+		if (!isExtendsElementView(view)) {
+			acc[view.id] = view;
+			return acc;
+		}
+		const extendsFrom = acc[view.extends];
+		if (!extendsFrom || !isElementView(extendsFrom)) return acc;
+		const tags = n([...extendsFrom.tags ?? [], ...view.tags ?? []]);
+		const links = [...extendsFrom.links ?? [], ...view.links ?? []];
+		acc[view.id] = {
+			...extendsFrom,
+			...view,
+			title: view.title ?? extendsFrom.title ?? null,
+			description: view.description ?? extendsFrom.description ?? null,
+			tags,
+			links: isNonEmptyArray(links) ? links : null,
+			rules: [...extendsFrom.rules, ...view.rules]
+		};
+		return acc;
+	}, {});
 }
 
+//#endregion
+//#region src/compute-view/utils/with-readable-edges.ts
+/**
+* Convert hashed edge ids to human-readable
+* Mostly for testing purposes
+*/
 function withReadableEdges({ edges, nodes, ...view }, separator = ":") {
-  const edgeids = t$2(edges, (e) => [e.id, `${e.source}${separator}${e.target}`]);
-  return {
-    ...view,
-    edges: edges.map((e) => ({
-      ...e,
-      id: edgeids[e.id]
-    })),
-    nodes: nodes.map((n) => ({
-      ...n,
-      inEdges: t$3(n.inEdges, (e) => edgeids[e]),
-      outEdges: t$3(n.outEdges, (e) => edgeids[e])
-    })),
-    nodeIds: nodes.map((n) => n.id),
-    edgeIds: edges.map((e) => edgeids[e.id])
-  };
+	const edgeids = t$1(edges, (e) => [e.id, `${e.source}${separator}${e.target}`]);
+	return {
+		...view,
+		edges: edges.map((e) => ({
+			...e,
+			id: edgeids[e.id]
+		})),
+		nodes: nodes.map((n) => ({
+			...n,
+			inEdges: t$2(n.inEdges, (e) => edgeids[e]),
+			outEdges: t$2(n.outEdges, (e) => edgeids[e])
+		})),
+		nodeIds: nodes.map((n) => n.id),
+		edgeIds: edges.map((e) => edgeids[e.id])
+	};
 }
 function viewsWithReadableEdges({ views, ...model }) {
-  return {
-    ...model,
-    views: t$1(views, (v) => n$1(withReadableEdges(v), ["nodeIds", "edgeIds"]))
-  };
+	return {
+		...model,
+		views: t$3(views, (v) => n$1(withReadableEdges(v), ["nodeIds", "edgeIds"]))
+	};
 }
 
-export { resolveRulesExtendedViews, viewsWithReadableEdges, withReadableEdges };
+//#endregion
+//#region src/compute-view/projects-view/compute.ts
+const keysCount = (object) => t$4(object).length;
+const nodeId = (projectId) => stringHash(projectId);
+/**
+* Computes an overview of projects and their relationships
+*/
+function computeProjectsView(likec4models) {
+	const nodesMap = buildNodesForEachModel(likec4models);
+	const key = (from, to) => `${from}->${to}`;
+	const relationships = new import_default_map.default((key) => {
+		const [from, to] = key.split("->");
+		return {
+			from,
+			to,
+			relationships: /* @__PURE__ */ new Set()
+		};
+	});
+	const relationshipsFromTo = (from, to) => relationships.get(key(from, to)).relationships;
+	const processImportedElement = (model, importedElement) => {
+		const projectId = importedElement.projectId;
+		invariant(projectId !== model.projectId, "Imported element must have a different project id");
+		const incoming = relationshipsFromTo(model.projectId, projectId);
+		for (const rel of importedElement.incoming("direct")) if (rel.source.projectId === model.projectId) incoming.add(rel);
+		const outgoing = relationshipsFromTo(projectId, model.projectId);
+		for (const rel of importedElement.outgoing("direct")) if (rel.target.projectId === model.projectId) outgoing.add(rel);
+	};
+	for (const model of likec4models) {
+		if (e(model.$data.imports)) continue;
+		for (const [projectId, imported] of t$5(model.$data.imports)) for (const importedElement of imported) {
+			const fqn = GlobalFqn(projectId, importedElement.id);
+			processImportedElement(model, nonNullable(model.findElement(fqn), `Element ${importedElement.id} from project ${projectId} not found in model ${model.projectId}`));
+		}
+	}
+	const edges = Array.from(relationships.entries()).filter(([_, { relationships }]) => relationships.size > 0).map(([key, { from, to, relationships: relationshipsSet }]) => {
+		const relationships = [...relationshipsSet];
+		invariant(t$6(relationships, 1), "Relationships set must have at least one relationship");
+		const edge = {
+			id: stringHash(key),
+			source: nodeId(from),
+			target: nodeId(to),
+			projectId: from,
+			relations: t$2(relationships, e$1("id")),
+			label: null,
+			color: "gray",
+			parent: null,
+			line: "solid",
+			tags: n(t$7(relationships, e$1("tags")))
+		};
+		const onlyOne = t$8(relationships);
+		if (onlyOne) {
+			edge.label = onlyOne.title;
+			edge.description = /* @__PURE__ */ preferSummary(onlyOne.$relationship) ?? null;
+			edge.technology = onlyOne.technology;
+			edge.color = onlyOne.color;
+			edge.line = onlyOne.line;
+			if (onlyOne.kind) edge.kind = onlyOne.kind;
+			if (onlyOne.$relationship.navigateTo) edge.navigateTo = onlyOne.$relationship.navigateTo;
+		}
+		return edge;
+	});
+	linkNodesWithEdges(nodesMap, edges);
+	const sorted = topologicalSort$1({
+		nodes: nodesMap,
+		edges
+	});
+	return {
+		id: "projects-view",
+		[_type]: "projects",
+		[_stage]: "computed",
+		title: "Projects",
+		description: { txt: "Overview of all projects and their relationships" },
+		autoLayout: { direction: "TB" },
+		...sorted
+	};
+}
+function buildNodesForEachModel(likec4models) {
+	const nodesMap = /* @__PURE__ */ new Map();
+	for (const model of likec4models) {
+		const projectId = ProjectId(model.projectId);
+		const node = {
+			id: nodeId(projectId),
+			kind: "@project",
+			parent: null,
+			projectId,
+			title: model.project.title ?? model.project.id,
+			description: { txt: [
+				`Elements: ${keysCount(model.$data.elements)}`,
+				`Relationships: ${keysCount(model.$data.relations)}`,
+				`Views: ${keysCount(model.$data.views)}`
+			].join("\n") },
+			shape: "rectangle",
+			children: [],
+			inEdges: [],
+			outEdges: [],
+			color: "primary",
+			level: 0,
+			style: {},
+			tags: []
+		};
+		nodesMap.set(node.id, node);
+	}
+	return nodesMap;
+}
+
+//#endregion
+//#region src/compute-view/adhoc-view/compute.ts
+/**
+* Computes an adhoc view based on the given predicates.
+* Adhoc views are not defined in the model, but computed on demand.
+* Available for logical model only.
+*
+* @param predicates accepts the same predicates as element view.
+* @param likec4model The LikeC4 model to compute view.
+* @returns The computed adhoc view.
+*/
+function computeAdhocView(likec4model, predicates) {
+	return {
+		...computeElementView(likec4model, {
+			id: ViewId("adhoc"),
+			_stage: "parsed",
+			_type: "element",
+			rules: predicates,
+			title: null,
+			description: null
+		}),
+		_type: "adhoc",
+		_stage: "computed"
+	};
+}
+
+//#endregion
+//#region src/compute-view/adhoc-view/builder.ts
+/**
+* Allows you to define type-safe adhoc views using types from the model.
+*/
+var AdhocView = class AdhocView {
+	/**
+	* Creates a new adhoc view builder.
+	*/
+	static use(model) {
+		return new AdhocView(model);
+	}
+	#predicates = [];
+	constructor(model) {
+		this.model = model;
+	}
+	/**
+	* Used to cache the type of the predicates.
+	*/
+	Expr;
+	include(...predicates) {
+		this.#predicates.push({ include: predicates.map((predicate) => $expr(predicate)) });
+		return this;
+	}
+	exclude(...predicates) {
+		this.#predicates.push({ exclude: predicates.map((predicate) => $expr(predicate)) });
+		return this;
+	}
+	compute() {
+		return computeAdhocView(this.model, this.#predicates);
+	}
+};
+
+//#endregion
+export { AdhocView, computeAdhocView, computeLikeC4Model, computeParsedModelData, computeProjectsView, computeRelationshipsView, computeView, resolveRulesExtendedViews, treeFromElements, unsafeComputeView, viewsWithReadableEdges, withReadableEdges };

package/dist/compute-view/relationships-view/index.d.mts

@@ -1,51 +1,16 @@
-import { A as Any, U as Unknown, a as ElementId, V as ViewId } from '../../shared/core.D00YbOhQ.mjs';
-import { E as ElementModel, R as RelationshipModel, f as LikeC4Model } from '../../shared/core.C-Jdx7xo.mjs';
-import 'type-fest';
-import '../../shared/core.DB0Ue5Wx.mjs';
-import '../../shared/core.C_3y3eqV.mjs';
-import '../../shared/core.DeDCYTDR.mjs';
-import '../../shared/core.BvPm_-u3.mjs';
-import '../../types/fqnRef.mjs';
-import '../../shared/core.DpKY_3NF.mjs';
-import '../../types/expression-model.mjs';
-import '../../shared/core.BPGOjone.mjs';
-import '../../shared/core.CywrQs86.mjs';
-import '../../shared/core.Ctj2S3bD.mjs';
-
-type RelationshipsViewData<M extends Any = Unknown> = {
-    incomers: ReadonlySet<ElementModel<M>>;
-    incoming: ReadonlySet<RelationshipModel<M>>;
-    subjects: ReadonlySet<ElementModel<M>>;
-    outgoing: ReadonlySet<RelationshipModel<M>>;
-    outgoers: ReadonlySet<ElementModel<M>>;
-};
-
-declare function computeRelationshipsView<M extends Any>(subjectId: ElementId<M>, likec4model: LikeC4Model<M>, scopeViewId: ViewId<M> | null, scope?: 'global' | 'view'): RelationshipsViewData<M>;
-
-declare function treeFromElements<M extends Any>(elements: Iterable<ElementModel<M>>): {
-    sorted: readonly ElementModel<M>[];
-    byId: (id: ElementId<M>) => ElementModel<M>;
-    root: ReadonlySet<ElementModel<M>>;
-    parent: (el: ElementModel<M>) => ElementModel<M> | null;
-    children: (el: ElementModel<M>) => ReadonlyArray<ElementModel<M>>;
-    /**
-     * Flattens the tree structure by removing redundant hierarchy levels.
-     * @example
-     *   A
-     *   └── B
-     *       ├── C
-     *       │   └── D
-     *       │       └── E
-     *       └── F
-     *           └── G
-     * becomes
-     *   A
-     *   ├── C
-     *   │   └── E
-     *   └── F
-     *       └── G
-     */
-    flatten: () => Set<ElementModel<M>>;
-};
-
-export { type RelationshipsViewData, computeRelationshipsView, treeFromElements };
+import "../../_chunks/_aux.mjs";
+import "../../_chunks/scalar.mjs";
+import "../../_chunks/expression.mjs";
+import "../../_chunks/fqnRef.mjs";
+import "../../_chunks/expression-model.mjs";
+import "../../_chunks/index2.mjs";
+import "../../_chunks/RichText.mjs";
+import "../../_chunks/index3.mjs";
+import "../../_chunks/LikeC4Model.mjs";
+import "../../_chunks/const.mjs";
+import "../../_chunks/find.mjs";
+import "../../_chunks/find2.mjs";
+import "../../_chunks/index4.mjs";
+import "../../_chunks/index5.mjs";
+import { n as computeRelationshipsView, r as RelationshipsViewData, t as treeFromElements } from "../../_chunks/index6.mjs";
+export { RelationshipsViewData, computeRelationshipsView, treeFromElements };